﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StringApplication
{
    // 定义一个基接口
    interface IBaseInterface
    {
        void Method1();
    }

    // 定义一个派生接口，继承自基接口
    interface IDerivedInterface : IBaseInterface
    {
        void Method2();
    }

    // 实现派生接口的类
    class MyClass : IDerivedInterface
    {
        public void Method1()
        {
            Console.WriteLine("方法1实施");
        }

        public void Method2()
        {
            Console.WriteLine("方法2实施");
        }
    }

    struct Books
    {
        public string title;
        public string author;
        public string subject;
        public int book_id;
    };

    class Box
    {
        private double length;   // 长度
        private double breadth;  // 宽度
        private double height;   // 高度
        public double getVolume()
        {
            return length * breadth * height;
        }

        public void setLength(double len)
        {
            length = len;
        }

        public void setBreadth(double bre)
        {
            breadth = bre;
        }

        public void setHeight(double hei)
        {
            height = hei;
        }

        // 重载 + 运算符来把两个 Box 对象相加
        public static Box operator +(Box b, Box c)
        {
            Box box = new Box();
            box.length = b.length + c.length;
            box.breadth = b.breadth + c.breadth;
            box.height = b.height + c.height;
            return box;
        }
    }

    class Line
    {
        private double length;   // 线条的长度
        public Line()
        {
            Console.WriteLine("对象已创建");
        }

        public void setLength(double len)
        {
            length = len;
        }
        public double getLength()
        {
            return length;
        }
    }

    class Line7
    {
        private double length7;   // 线条的长度
        public Line7(double len7)  // 参数化构造函数
        {
            Console.WriteLine("对象已创建，长度 = {0}", len7);
            length7 = len7;
        }

        public void setLength(double len7)
        {
            length7 = len7;
        }
        public double getLength()
        {
            return length7;
        }
    }

    class Line8
    {
        private double length8;   // 线条的长度
        public Line8()  // 构造函数
        {
            Console.WriteLine("对象已创建");
        }
        ~Line8() //析构函数
        {
            Console.WriteLine("对象已删除");
        }

        public void setLength(double len8)
        {
            length8 = len8;
        }
        public double getLength()
        {
            return length8;
        }
    }

    class StaticVar
    {
        public static int num;
        public void count()
        {
            num++;
        }
        public int getNum()
        {
            return num;
        }
    }

    class StaticVar9
    {
        public static int num9;
        public void count()
        {
            num9++;
        }
        public static int getNum()
        {
            return num9;
        }
    }

    class Shape
    {
        public void setWidth(int w10)
        {
            width10 = w10;
        }
        public void setHeight(int h10)
        {
            height10 = h10;
        }
        protected int width10;
        protected int height10;
    }

    // 派生类
    class Rectangle : Shape
    {
        public int getArea()
        {
            return (width10 * height10);
        }
    }

    class Rectangle11
    {
        // 成员变量
        protected double length11;
        protected double width11;
        public Rectangle11(double l11, double w11)
        {
            length11 = l11; width11 = w11;
        }
        public double GetArea()
        {
            return length11 * width11;
        }
        public void Display()
        {
            Console.WriteLine("长度： {0}", length11);
            Console.WriteLine("宽度： {0}", width11);
            Console.WriteLine("面积： {0}", GetArea());
        }
    }                                                                    // end class Rectangle11

    class Tabletop : Rectangle11
    {
        private double cost;
        public Tabletop(double l11, double w11) : base(l11, w11)
        { }
        public double GetCost()
        {
            double cost;
            cost = GetArea() * 70;
            return cost;
        }
        public void Display()
        {
            base.Display();
            Console.WriteLine("成本： {0}", GetCost());
        }
    }

    class Shape12
    {
        public void setWidth(int w12)
        {
            width12 = w12;
        }
        public void setHeight(int h12)
        {
            height12 = h12;
        }
        protected int width12;
        protected int height12;
    }

    // 基类 PaintCost
    public interface PaintCost12
    {
        int getCost(int area12);

    }

    // 派生类
    class Rectangle12 : Shape12, PaintCost12
    {
        public int getArea()
        {
            return (width12 * height12);
        }
        public int getCost(int area12)
        {
            return area12 * 70;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // 创建 MyClass 类的实例
            MyClass obj = new MyClass();

            // 调用继承自基接口的方法
            obj.Method1();

            // 调用派生接口新增的方法
            obj.Method2();

            Rectangle12 Rect12 = new Rectangle12();
            int area12;
            Rect12.setWidth(5);
            Rect12.setHeight(7);
            area12 = Rect12.getArea();
            // 打印对象的面积
            Console.WriteLine("总面积： {0}", Rect12.getArea());
            Console.WriteLine("油漆总成本： ${0}", Rect12.getCost(area12));

            Tabletop t = new Tabletop(4.5, 7.5);
            t.Display();

            Rectangle Rect = new Rectangle();

            Rect.setWidth(5);
            Rect.setHeight(7);

            // 打印对象的面积
            Console.WriteLine("总面积： {0}", Rect.getArea());

            StaticVar9 s9 = new StaticVar9();
            s9.count();
            s9.count();
            s9.count();
            Console.WriteLine("变量 num： {0}", StaticVar9.getNum());

            StaticVar s1 = new StaticVar();
            StaticVar s2 = new StaticVar();
            s1.count();
            s1.count();
            s1.count();
            s2.count();
            s2.count();
            s2.count();
            Console.WriteLine("s1 的变量 num： {0}", s1.getNum());
            Console.WriteLine("s2 的变量 num： {0}", s2.getNum());

            Line8 line8 = new Line8();
            // 设置线条长度
            line8.setLength(6.0);

            Line line = new Line();
            // 设置线条长度
            line.setLength(23.0);
            Console.WriteLine("线条的长度： {0}", line.getLength());

            Line7 line7 = new Line7(29.0);
            Console.WriteLine("线条的长度： {0}", line7.getLength());
            // 设置线条长度
            line7.setLength(29.0);
            Console.WriteLine("线条的长度： {0}", line7.getLength());

            Box Box1 = new Box();        // 声明 Box1，类型为 Box
            Box Box2 = new Box();        // 声明 Box2，类型为 Box
            Box Box3 = new Box();        // 声明 Box3，类型为 Box
            double volume;               // 体积

            // Box1 详述
            Box1.setLength(6.0);
            Box1.setBreadth(7.0);
            Box1.setHeight(5.0);

            // Box2 详述
            Box2.setLength(12.0);
            Box2.setBreadth(13.0);
            Box2.setHeight(10.0);

            // Box1 的体积
            volume = Box1.getVolume();
            Console.WriteLine("盒子1的体积： {0}", volume);

            // Box2 的体积
            volume = Box2.getVolume();
            Console.WriteLine("盒子2的体积： {0}", volume);

            // 把两个对象相加
            Box3 = Box1 + Box2;

            // Box3 的体积
            volume = Box3.getVolume();
            Console.WriteLine("盒子3的体积： {0}", volume);

            //字符串，字符串连接
            string fname, lname;
            fname = "郦";
            lname = "瀚森";

            string fullname = fname + lname;
            Console.WriteLine("全名： {0}", fullname);

            //通过使用 string 构造函数
            char[] letters = { '郦', '瀚', '森', '你', '好'  };
            string greetings = new string(letters);
            Console.WriteLine("Greetings: {0}", greetings);

            //方法返回字符串
            string[] sarray = { "Hello", "From", "Tutorials", "Point" };
            string message = String.Join(" ", sarray);
            Console.WriteLine("信息： {0}", message);

            //用于转化值的格式化方法
            DateTime waiting = new DateTime(2012, 10, 10, 17, 58, 1);
            string chat = String.Format("信息发送在 {0:D} 的 {0:t}",
            waiting);
            Console.WriteLine("信息： {0}", chat);

            string str1 = "这个测试";
            string str2 = "这个文本";

            if (String.Compare(str1, str2) == 0)
            {
                Console.WriteLine(str1 + " 和 " + str2 + " 相等。");
            }
            else
            {
                Console.WriteLine(str1 + " 和 " + str2 + " 不相等。");
            }

            string str3 = "这个测试";
            if (str3.Contains("测试"))
            {
                Console.WriteLine(" 这个序列“测试”找不到 ");
            }

            string str4 = "Last night I dreamt of 郦瀚森";
            Console.WriteLine(str4);
            string substr = str4.Substring(23);
            Console.WriteLine(substr);

            string[] starray = new string[]{ "前方的夜晚漆黑一片，\r\n而山顶每日都沐浴在阳光下。" };

            string str5 = String.Join("\n", starray);
            Console.WriteLine(str5);

            Books Book1;        /* 声明 Book1，类型为 Books */
            Books Book2;        /* 声明 Book2，类型为 Books */

            /* book 1 详述 */
            Book1.title = "C 语言";
            Book1.author = "努哈阿里";
            Book1.subject = "C 语言编程教程";
            Book1.book_id = 6495407;

            /* book 2 详述 */
            Book2.title = "电信计费";
            Book2.author = "Zara阿里";
            Book2.subject = "电信计费教程";
            Book2.book_id = 6495700;

            /* 打印 Book1 信息 */
            Console.WriteLine("书一名称 : {0}", Book1.title);
            Console.WriteLine("书一作者 : {0}", Book1.author);
            Console.WriteLine("书一教程 : {0}", Book1.subject);
            Console.WriteLine("书一书id :{0}", Book1.book_id);

            /* 打印 Book2 信息 */
            Console.WriteLine("书二名称 : {0}", Book2.title);
            Console.WriteLine("书二作者 : {0}", Book2.author);
            Console.WriteLine("书二教程 : {0}", Book2.subject);
            Console.WriteLine("书二书id : {0}", Book2.book_id);

            int[] array13 = { 1, 8, 4, 8, 7, 45, 456, 789, 78, 76 };

            for (int i13 = 0; i13 < array13.Length; i13++)
            {
                Console.WriteLine(i13 + ":" + array13[i13]);
            }

            int[] array14 = { 1, 4, 4, 5, 5, 88, 5544, 789, 78, 76 };

            for (int i14 = 0; i14 < array14.Length; i14++)
            {
                bool lhs = false; // 立个flag，表示判断过程中是否发生了交换

                for (int j14 = 0; j14 < array14.Length - i14 - 1; j14++)
                {
                    if (array14[j14] > array14[j14 + 1])
                    {
                        lhs = true;  // 说明交换了
                        int temp14 = array14[j14];  // 交换
                        array14[j14] = array14[j14 + 1];
                        array14[j14 + 1] = temp14;
                    }
                }

                if (!lhs)
                {
                    break;  // 说明已经排好序了，后面的轮次就没有必要了
                }

                for (int m14 = 0; m14 < array14.Length; m14++)
                {
                    Console.Write(array14[m14] + "\t");
                }

                Console.WriteLine();
            }

            Console.WriteLine("排序结束");

            for (int m14 = 0; m14 < array14.Length; m14++)
            {
                Console.Write(array14[m14] + "\t");
            }

            int[,] array15 = new int[,] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }, { 10, 11, 12 } };

            for (int i15 = 0; i15 < array15.GetLength(0); i15++)  // 使用for循环遍历二维数组
            {
                for (int f15 = 0; f15 < array15.GetLength(1); f15++)
                {
                    Console.WriteLine(array15[i15,f15]);
                }
            }
            
            int[,,] arr16 = new int[,,]  // 定义三维数组
            {
                  {
                         {2, 3}
                  },
                  {
                         {2, 9}
                  }
            };
            
            // 使用foreach遍历三维数组(遍历多维数组用foreach简单的多)
            foreach (var val in arr16)
            {
                Console.WriteLine(val);  //输出 2329
            }

            /* 一个由 5 个整型数组组成的交错数组 */
            int[][] aaa = new int[][] { new int[] { 0, 0 }, new int[] { 1, 2 }, new int[] { 2, 4 }, new int[] { 3, 6 }, new int[] { 4, 8 } };

            /* 输出数组中每个元素的值 */
            for (int ii = 0; ii < 5; ii++)
            {
                for (int jj = 0; jj < 2; jj++)
                {
                    Console.WriteLine("aaa[{0}][{1}] = {2}", ii, jj, aaa[ii][jj]);
                }
            }

            int[][] ab = new int[3][];  // 以下是声明交错数组的每一个元素的，每个数组的长度可以不同
            ab[0] = new int[] { 1, 2, 3 };
            ab[1] = new int[] { 4, 5, 6, 7, 8 };
            ab[2] = new int[] { 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 };

            foreach (var value in ab)  // foreach 输出
            {
                Console.WriteLine(value);
                foreach (var item in value)
                {
                    Console.WriteLine(item);
                }
            }

            int[] one = new int[] { 1, 2, 3, 4, 5, 6, 7 }; // 从当前的一维数组中复制所有的元素
            int[] two = new int[] { 11, 22, 33, 44, 55, 66, 77, 88, 99, 100 }; // 到一个指定的一维数组的指定索引位置
            one.CopyTo(two, 1);
            foreach (var item in two)
            {
                Console.WriteLine(item);  
            }

            int nums = one.GetLength(0);
            Console.WriteLine(nums);  // GetLength 获取一个 32 位整数，该值表示指定维度的数组中的元素总数

            int numss = two.GetLength(0);
            Console.WriteLine(numss);  //输出10

            int rand = array15.GetLowerBound(1);
            Console.WriteLine(rand);  //输出0

            int randss = array15.GetUpperBound(0);
            Console.WriteLine(randss);  //输出3

            Console.WriteLine(one.GetType());

            int[] three = new int[] { 1, 2, 3, 4, 5, 6, 7 };
            int we = (int)three.GetValue(0);  // GetValue获取的是一个对象，GetValue(Int32)获取一维数组中指定位置的值。索引由一个 32 位整数指定
            Console.WriteLine(we);

            int vv = Array.IndexOf(three, 3);
            Console.WriteLine(vv);  // IndexOf(Array, Object) 搜索指定的对象，返回整个一维数组中第一次出现的索引

            Array.Reverse(three);
            foreach (var item in three)
            {
                Console.WriteLine(item); // Reverse(Array)逆转整个一维数组中元素的顺序。
            }

            Array.Sort(three);
            foreach (var item in three)
            {
                Console.WriteLine(item);  // Sort(Array)使用数组的每个元素的 IComparable 实现来排序整个一维数组中的元素          
            }

            three.SetValue(22, 3);
            foreach (var item in three)
            {
                Console.WriteLine(item); // 输出1（0）/22（1）/3（2）/4（3）/5/6/7
            }

            string str11111 = three.ToString();
            Console.WriteLine(str11111);   // ToString 返回一个表示当前对象的字符串。从对象（Object）继承

            // 定义一个二维数组
            int[,] qq = new int[,] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }, { 10, 11, 12 } };

            bool res = qq.IsFixedSize;
            Console.WriteLine(res); // IsFixedSize 获取一个值，该值指示数组是否带有固定大小

            bool ult = qq.IsReadOnly;
            Console.WriteLine(ult);  // IsReadOnly 获取一个值，该值指示数组是否只读

            int total = qq.Length;
            Console.WriteLine(total);  //Length 获取一个 32 位整数，该值表示所有维度的数组中的元素总数

            int totals = qq.Length;
            Console.WriteLine(totals);  //输出12

            int asd = qq.Rank;
            Console.WriteLine(asd);  //2  此为二维数组

            Array.Clear(qq, 0, qq.Length);  //清空数组（前边的Array是固定的）
            foreach (var item in qq)
            {
                Console.WriteLine(item);
            }

            Array.Copy(qq, array15, 2);
            foreach (var item in array15)
            {
                Console.WriteLine(item);  // Copy(Array, Array, Int32)从数组的第一个元素开始复制某个范围的元素到另一个数组的第一个元素位置。长度由一个 32 位整数指定
            }

            EquipType myEquip = EquipType.Knapsack;  //  定义一个枚举类型的变量
            EquipType yourEquip = EquipType.Knapsack;
            if (myEquip == EquipType.BodyArmor) { }  //  判断枚举变量
            switch (myEquip)
            {
                case EquipType.BodyArmor:
                    break;
                case EquipType.Helmet:
                    break;
                case EquipType.Knife:
                    break;
                default:  //case EquipType
                    break;
            }
            
            int num = (int)myEquip;  //  枚举类型和整型之间的转换，枚举类型可以强制转换为整型
            Console.WriteLine(num);
            myEquip = (EquipType)200;  //  整型可以强制转换为枚举类型
            Console.WriteLine(myEquip);
            Console.WriteLine(myEquip + 2);  //  既然枚举可以用整数去表示
            Console.ReadKey();
        }
    }

    enum EquipType  //装备类型
    {
        Helmet = 100,//头盔
        BodyArmor = 200,//防弹衣
        Knapsack,//背包
        Knife
    }
}